package com.apobates.forum.toro;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.util.Collection;
import java.util.Optional;
import java.util.function.Consumer;
import java.util.function.Function;
import java.util.stream.Collectors;

/**
 * 最终结果处理函数
 * @param <E> 处理前的对象类型
 * @param <F> 处理后的对象类型
 */
public interface ResultMapperTransfer<E,F> {
    final static Logger logger = LoggerFactory.getLogger(ResultMapperTransfer.class);

    /**
     * 消费函数/前置处理
     * @return
     */
    Consumer<E> getConsumer();

    /**
     * 映射函数/后置转换
     * @return
     */
    Function<E,F> getFormater();

    /**
     * 返回一个空处理实现
     * @return
     * @param <E> 处理前的对象类型
     * @param <F> 处理后的对象类型
     */
    static <E,F> ResultMapperTransfer<E,F> empty(){
        return new ResultMapperTransfer<E, F>() {
            @Override
            public Consumer<E> getConsumer() {
                return (E ins)->logger.info("ResultMapperTransfer Default Consumer");
            }

            @Override
            public Function<E, F> getFormater() {
                return (E ins)->(F)ins;
            }
        };
    }

    /**
     * 处理单实例结果
     * @param result 实例结果
     * @return
     */
    default Optional<F> get(Optional<E> result) {
        result.ifPresent(getConsumer());
        return result.map(getFormater());
    }

    /**
     * 处理实例集合结果
     * @param result 实例集合
     * @return
     */
    default Collection<F> getAll(Collection<E> result) {
        result.forEach(getConsumer());
        return result.stream().map(getFormater()).collect(Collectors.toList());
    }
}
